/**
 * Created by YJH on 2018/5/29.
 */

import {AsyncStorage, DeviceEventEmitter,} from 'react-native';
import GitHubTrending from 'GitHubTrending';

export const FLAG_STORAGE = {flag_popular: 'popular', flag_trending: 'trending', flag_my: 'flag_my'};
export default class DataRespository {
    constructor(flag) {
        this.flag = flag;
        if (this.flag === FLAG_STORAGE.flag_trending) {
            this.trending = new GitHubTrending();
        }

    }

    /** 检测时间有没有过时的方法
     * 过时返回false
     * */
    checkData(longTime) {
        // return false;
        let cDate = new Date();//当前
        let tDate = new Date();//目标


        tDate.setTime(longTime);
        if (cDate.getMonth() !== tDate.getMonth())return false;
        if (cDate.getDay() !== tDate.getDay())return false;
        if (cDate.getHours() - tDate.getHours() > 4)return false;

        return true;
    }

    /** 保存数据到本地的方法*/
    saveRepository(url, items, callback) {
        if (!url || !items)return;
        let wrapData;
        if (this.flag === FLAG_STORAGE.flag_my) {
            wrapData = {item: items, update_date: new Date().getTime()};
        } else {
            wrapData = {items: items, update_date: new Date().getTime()};
        }
        AsyncStorage.setItem(url, JSON.stringify(wrapData), callback);
    }

    fetNetRespository(url) {
        return new Promise((resolve, reject) => {
            if (this.flag === FLAG_STORAGE.flag_trending) {
                //在热搜模块进行数据的获取
                this.trending.fetchTrending(url)
                    .then(result => {
                        if (!result) {
                            //如果从网络上获取的数据为空，那么告诉调用者
                            reject(new Error('获取的数据为空'));
                            return;
                        }
                        resolve(result);
                        //缓存数据到本地
                        this.saveRepository(url, result);
                    })
                    .catch(error => {
                        reject(error);
                    });

                return;
            }


            fetch(url)
                .then(response => response.json())
                .then(result => {
                    if (this.flag === FLAG_STORAGE.flag_my && result) {
                        //缓存数据到本地
                        this.saveRepository(url, result);
                        resolve(result);
                    } else if (result && result.items) {
                        this.saveRepository(url, result.items);
                        resolve(result.items);
                    } else {
                        //如果从网络上获取的数据为空，那么告诉调用者
                        reject(new Error('获取的数据为空'));
                    }
                })
                .catch(error => {
                    reject(error);
                })
        })
    }

    /** 获取本地数据的方法*/
    fetchLocalRespository(url) {
        return new Promise((resolve, reject) => {
            AsyncStorage.getItem(url, (error, result) => {
                if (!error) {
                    //如若正确获取本地的数据
                    try {
                        resolve(JSON.parse(result));//回调给用户
                    } catch (err) {
                        reject(err);//反馈给用户
                    }
                } else {
                    reject(error);//反馈给用户
                }
            })
        });

    }


    /** 着眼于获取数据，分别会从本地和网络进行拉取需要的数据
     * 本地数据返回来的是“[items:[], update_date:[]]”
     * 网络数据返回来的是“[]”
     * */
    fetchRespository(url) {
        return new Promise((resolve, reject) => {
            //获取本地数据
            this.fetchLocalRespository(url)
                .then(wrapData => {
                    if (wrapData) {
                        resolve(wrapData)
                    }
                    else {
                        //当本地数据为空，加载网络数据
                        this.fetNetRespository(url)
                            .then(items => {
                                // let wrapData = {items: items, update_date: new Date().getTime()};
                                resolve(items);
                            }).catch(err => {
                            reject(err)
                        })
                    }
                })
                .catch(error => {
                    this.fetNetRespository(url)
                        .then(items => {
                            // let wrapData = {items: items, update_date: new Date().getTime()};
                            resolve(items);
                        })
                        .catch(err => {
                            reject(err);
                        })
                })
        });

    }
}